SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Java syntax</title>

</head>

Java syntax

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">See also: <a href="Java_(programming_language)#Syntax" title="Java (programming language)">Java (programming language) § Syntax</a></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style>

The syntax of Java is <a href="Syntax" title="Syntax">the set of rules</a> defining how a <a href="Java_(programming_language)" title="Java (programming language)">Java</a> program is written and interpreted.

The <a href="Syntax_(programming_languages)" title="Syntax (programming languages)">syntax</a> is mostly derived from <a href="C_(programming_language)" title="C (programming language)">C</a> and <a href="C%2B%2B" title="C++">C++</a>. Unlike C++, Java has no global functions or variables, but has data members which are also regarded as <a href="Global_variable" title="Global variable">global variables</a>. All code belongs to <a href="Class_(computer_programming)" title="Class (computer programming)">classes</a> and all values are <a href="Object_(computer_science)" title="Object (computer science)">objects</a>. The only exception is the <a href="Primitive_data_types" class="mw-redirect" title="Primitive data types">primitive data types</a>, which are not considered to be objects for performance reasons (though can be automatically converted to objects and vice versa via <a href="#Boxing_and_unboxing">autoboxing</a>). Some features like <a href="Operator_overloading" title="Operator overloading">operator overloading</a> or <a href="Unsigned_integer" class="mw-redirect" title="Unsigned integer">unsigned integer</a> <a href="Data_type" title="Data type">data types</a> are omitted to simplify the language and avoid possible programming mistakes.

The Java syntax has been gradually extended in the course of numerous major <a href="JDK" class="mw-redirect" title="JDK">JDK</a> <a href="Java_version_history" title="Java version history">releases</a>, and now supports abilities such as <a href="Generic_programming" title="Generic programming">generic programming</a> and <a href="Anonymous_function" title="Anonymous function">anonymous functions</a> (function literals, called lambda expressions in Java). Since 2017, a new JDK version is released twice a year, with each release improving the language incrementally.

<div class="mw-heading mw-heading2"><h2 id="Basics">Basics</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Identifier">Identifier</h3></div>

An <a href="Identifier#In_computer_languages" title="Identifier">identifier</a> is the name of an element in the <a href="Source_code" title="Source code">code</a>. There are certain standard <a href="Naming_conventions_(programming)" class="mw-redirect" title="Naming conventions (programming)">naming conventions</a> to follow when selecting names for elements. Identifiers in Java are <a href="Case_sensitivity" title="Case sensitivity">case-sensitive</a>.

An identifier can contain:

<ul><li>Any Unicode character that is a letter (including numeric letters like <a href="Roman_numerals" title="Roman numerals">Roman numerals</a>) or digit.</li>

<li><a href="Currency_sign" class="mw-redirect" title="Currency sign">Currency sign</a> (such as ¥).</li>

<li>Connecting punctuation character (such as <a href="Underscore" title="Underscore">_</a>).</li></ul>

An identifier cannot:

<ul><li>Start with a digit.</li>

<li>Be equal to a reserved keyword, null literal or <a href="Boolean_data_type" title="Boolean data type">Boolean</a> literal.</li></ul>

<div class="mw-heading mw-heading3"><h3 id="Keywords">Keywords</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="List_of_Java_keywords" title="List of Java keywords">List of Java keywords</a></div>

<div class="mw-heading mw-heading4"><h4 id="Keywords_2">Keywords</h4></div>

The following words are keywords and cannot be used as identifiers under any circumstances.

/* start https://en.wikipedia.org/ */

.mw-parser-output .div-col{margin-top:0.3em;column-width:30em}.mw-parser-output .div-col-small{font-size:90%}.mw-parser-output .div-col-rules{column-rule:1px solid #aaa}.mw-parser-output .div-col dl,.mw-parser-output .div-col ol,.mw-parser-output .div-col ul{margin-top:0}.mw-parser-output .div-col li,.mw-parser-output .div-col dd{page-break-inside:avoid;break-inside:avoid-column}

/* end https://en.wikipedia.org/ */

</style><div class="div-col" style="column-width: 15em;">

<li><code>abstract</code></li>

<li><code>assert</code></li>

<li><code>boolean</code></li>

<li><code>break</code></li>

<li><code>catch</code></li>

<li><code>class</code></li>

<li><code>continue</code></li>

<li><code>default</code></li>

<li><code>double</code></li>

<li><code>extends</code></li>

<li><code>final</code></li>

<li><code>finally</code></li>

<li><code>float</code></li>

<li><code>implements</code></li>

<li><code>import</code></li>

<li><code>instanceof</code></li>

<li><code>interface</code></li>

<li><code>native</code></li>

<li><code>package</code></li>

<li><code>private</code></li>

<li><code>protected</code></li>

<li><code>public</code></li>

<li><code>return</code></li>

<li><code>short</code></li>

<li><code>static</code></li>

<li><code>super</code></li>

<li><code>switch</code></li>

<li><code>synchronized</code></li>

<li><code>throw</code></li>

<li><code>throws</code></li>

<li><code>transient</code></li>

<li><code>volatile</code></li>

<li><code>while</code></li></ul>

</div>

<div class="mw-heading mw-heading4"><h4 id="Reserved_identifiers">Reserved identifiers</h4></div>

The following words are contextual keywords and are only restricted in certain contexts.

<ul><li><code>exports</code></li>

<li><code>module</code></li>

<li><code>non-sealed</code></li>

<li><code>opens</code></li>

<li><code>permits</code></li>

<li><code>provides</code></li>

<li><code>record</code></li>

<li><code>requires</code></li>

<li><code>sealed</code></li>

<li><code>transitive</code></li>

<li><code>yield</code></li></ul>

</div>

<div class="mw-heading mw-heading4"><h4 id="Reserved_words_for_literal_values">Reserved words for literal values</h4></div>

The following words refer to literal values used by the language.

<li><code>false</code></li>

</div>

<div class="mw-heading mw-heading4"><h4 id="Unused">Unused</h4></div>

The following words are reserved as keywords, but currently have no use or purpose.

<ul><li><code>const</code></li>

<li><code>strictfp</code></li></ul>

</div>

<div class="mw-heading mw-heading3"><h3 id="Literals">Literals</h3></div>

<th colspan="2">Integers

</th></tr>

<tr>

<th><a href="Binary_numeral_system" class="mw-redirect" title="Binary numeral system">binary</a> (introduced in Java SE 7)

</th>

/* start https://en.wikipedia.org/ */

.mw-parser-output .monospaced{font-family:monospace,monospace}

/* end https://en.wikipedia.org/ */

</style>0b11110101 (0b followed by a binary number)

</td></tr>

<tr>

<th><a href="Octal" title="Octal">octal</a>

</th>

<td>0365 (0 followed by an octal number)

</td></tr>

<tr>

<th><a href="Hexadecimal" title="Hexadecimal">hexadecimal</a>

</th>

<td>0xF5 (0x followed by a hexadecimal number)

</td></tr>

<tr>

<th><a href="Decimal" title="Decimal">decimal</a>

</th>

<td>245 (decimal number)

</td></tr>

<tr>

<th colspan="2"><a href="Floating-point" class="mw-redirect" title="Floating-point">Floating-point</a> values

</th></tr>

<tr>

<th rowspan="2">float

</th>

<td>23.5F, .5f, 1.72E3F (decimal fraction with an optional exponent indicator, followed by F)

</td></tr>

<tr>

<td>0x.5FP0F, 0x.5P-6f (0x followed by a hexadecimal fraction with a mandatory exponent indicator and a suffix F)

</td></tr>

<tr>

<th rowspan="2">double

</th>

<td>23.5D, .5, 5., 1.72E3D (decimal fraction with an optional exponent indicator, followed by optional D)

</td></tr>

<tr>

<td>0x.5FP0, 0x.5P-6D (0x followed by a hexadecimal fraction with a mandatory exponent indicator and an optional suffix D)

</td></tr>

<tr>

<th colspan="2">Character literals

</th></tr>

<tr>

<th>char

</th>

<td>'a', 'Z', '\u0231' (character or a character escape, enclosed in single quotes)

</td></tr>

<tr>

<th colspan="2">Boolean literals

</th></tr>

<tr>

<th>boolean

</th>

<td>true, false

</td></tr>

<tr>

<th colspan="2">null literal

</th></tr>

<tr>

<th>null reference

</th>

<td>null

</td></tr>

<tr>

<th colspan="2">String literals

</th></tr>

<tr>

<th>String

</th>

<td>"Hello, World" (sequence of characters and character escapes enclosed in double quotes)

</td></tr>

<tr>

<th colspan="2">Characters escapes in strings

</th></tr>

<tr>

<th><a href="Unicode" title="Unicode">Unicode</a> character

</th>

<td>\u3876 (\u followed by the hexadecimal unicode code point up to U+FFFF)

</td></tr>

<tr>

<th><a href="Octal" title="Octal">Octal</a> escape

</th>

<td>\352 (octal number not exceeding 377, preceded by backslash)

</td></tr>

<tr>

</th>

<td>\n

</td></tr>

<tr>

<th><a href="Carriage_return" title="Carriage return">Carriage return</a>

</th>

<td>\r

</td></tr>

<tr>

</th>

<td>\f

</td></tr>

<tr>

<th><a href="Backslash" title="Backslash">Backslash</a>

</th>

<td>\\

</td></tr>

<tr>

<th><a href="Single_quote" class="mw-redirect" title="Single quote">Single quote</a>

</th>

<td>\'

</td></tr>

<tr>

<th><a href="Double_quote" class="mw-redirect" title="Double quote">Double quote</a>

</th>

<td>\"

</td></tr>

<tr>

</th>

<td>\t

</td></tr>

<tr>

<th><a href="Backspace" title="Backspace">Backspace</a>

</th>

<td>\b

</td></tr></tbody></table>

Integer literals are of <code>int</code> type by default unless <code>long</code> type is specified by appending <code>L</code> or <code>l</code> suffix to the literal, e.g. <code>367L</code>. Since Java SE 7, it is possible to include underscores between the digits of a number to increase readability; for example, a number 145608987 can be written as 145_608_987.

<div class="mw-heading mw-heading3"><h3 id="Variables">Variables</h3></div>

<a href="Variable_(computer_science)" title="Variable (computer science)">Variables</a> are identifiers associated with values. They are declared by writing the variable's type and name, and are optionally initialized in the same statement by assigning a value.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int count; //Declaring an uninitialized variable called 'count', of type 'int'

count = 35; //Initializing the variable

int count = 35; //Declaring and initializing the variable at the same time

</pre></div>

Multiple variables of the same type can be declared and initialized in one statement using comma as a delimiter.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int a, b; //Declaring multiple variables of the same type

int a = 2, b = 3; //Declaring and initializing multiple variables of the same type

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Type_inference">Type inference</h4></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Type_inference" title="Type inference">Type inference</a></div>

Since Java 10, it has become possible to <a href="Type_inference" title="Type inference">infer types</a> for the variables automatically by using <code>var</code>.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// stream will have the FileOutputStream type as inferred from its initializer

var stream = new FileOutputStream("file.txt");

// An equivalent declaration with an explicit type

FileOutputStream stream = new FileOutputStream("file.txt");

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Code_blocks">Code blocks</h3></div>

The separators { and } signify a code block and a new scope. Class members and the body of a <a href="Method_(computer_programming)" title="Method (computer programming)">method</a> are examples of what can live inside these braces in various contexts.

Inside of method bodies, braces may be used to create new scopes, as follows:

int a;

{

int b;

a = 1;

}

a = 2;

b = 3; // Illegal because the variable b is declared in an inner scope..

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Comments">Comments</h3></div>

Java has three kinds of <a href="Comment_(computer_programming)" title="Comment (computer programming)">comments</a>: traditional comments, end-of-line comments and documentation comments.

Traditional comments, also known as block comments, start with <code>/*</code> and end with <code>*/</code>, they may span across multiple lines. This type of comment was derived from C and C++.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>/* This is a multi-line comment.

It may occupy more than one line. */

</pre></div>

End-of-line comments start with <code>//</code> and extend to the end of the current line. This comment type is also present in C++ and in modern C.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// This is an end-of-line comment

</pre></div>

Documentation comments in the source files are processed by the <a href="Javadoc" title="Javadoc">Javadoc</a> tool to generate documentation. This type of comment is identical to traditional comments, except it starts with <code>/**</code> and follows conventions defined by the Javadoc tool. Technically, these comments are a special kind of traditional comment and they are not specifically defined in the language specification.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>/**

* This is a documentation comment.

*

* @author John Doe

*/

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Universal_types">Universal types</h3></div>

Classes in the package java.lang are implicitly imported into every program, as long as no explicitly-imported types have the same names. Important ones include:

<div class="mw-heading mw-heading4"><h4 id="java.lang.Object">java.lang.Object</h4></div>

<code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">java.lang.Object</code> is Java's <a href="Top_type" class="mw-redirect" title="Top type">top type</a>. It is implicitly the superclass of all classes that do not declare any parent class (thus all classes in Java inherent from <code>Object</code>. All values can be converted to this type, although for primitive values this involves <a href="Object_type_(object-oriented_programming)" class="mw-redirect" title="Object type (object-oriented programming)">autoboxing</a>.

<div class="mw-heading mw-heading4"><h4 id="java.lang.String">java.lang.String</h4></div>

<code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">java.lang.String</code> is Java's basic string type. <a href="Immutable_object" title="Immutable object">Immutable</a>. Some methods treat each <a href="UTF-16" title="UTF-16">UTF-16</a> code unit as a "character", but methods to convert to an <code>int[]</code> that is effectively <a href="UTF-32" title="UTF-32">UTF-32</a> are also available.

<div class="mw-heading mw-heading4"><h4 id="java.lang.Throwable">java.lang.Throwable</h4></div>

<code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">java.lang.Throwable</code> is supertype of everything that can be <a href="Exception_handling" title="Exception handling">thrown or caught</a> with Java's <code>throw</code> and <code>catch</code> statements.

<div class="mw-heading mw-heading2"><h2 id="Program_structure">Program structure</h2></div>

Java applications consist of collections of classes. Classes exist in packages but can also be nested inside other classes.

<div class="mw-heading mw-heading3"><h3 id="main_method"><code>main</code> method</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Entry_point#Java" title="Entry point">Entry point § Java</a></div>

Every Java application must have an entry point. This is true of both graphical interface applications and console applications. The entry point is the <code>main</code> method. There can be more than one class with a <code>main</code> method, but the main class is always defined externally (for example, in a <a href="Manifest_file" title="Manifest file">manifest file</a>). The <code>main</code> method along with the main class must be declared <code>public</code>. The method must be <code>static</code> and is passed command-line arguments as an array of strings. Unlike <a href="C%2B%2B" title="C++">C++</a> or <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>, it never returns a value and must return <code>void</code>.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public static void main(String[] args) {

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Packages">Packages</h3></div>

Packages are a part of a class name and they are used to group and/or distinguish named entities from other ones. Another purpose of packages is to govern code access together with access modifiers. For example, <code>java.io.InputStream</code> is a fully qualified class name for the class <code>InputStream</code> which is located in the package <code>java.io</code>.

A package is declared at the start of the file with the <code>package</code> declaration:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>package myapplication.mylibrary;

public class MyClass {

}

</pre></div>

Classes with the <code>public</code> modifier must be placed in the files with the same name and java extension and put into nested folders corresponding to the package name. The above class <code>myapplication.mylibrary.MyClass</code> will have the following path: <code>myapplication/mylibrary/MyClass.java</code>.

<div class="mw-heading mw-heading3"><h3 id="Import_declaration">Import declaration</h3></div>

<div class="mw-heading mw-heading4"><h4 id="Type_import_declaration">Type import declaration</h4></div>

A type import declaration allows a named type to be referred to by a simple name rather than the full name that includes the package. Import declarations can be single type import declarations or import-on-demand declarations. Import declarations must be placed at the top of a code file after the package declaration.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>package myPackage;

import java.util.Random; // Single type declaration

public class ImportsTest {

public static void main(String[] args) {

/* The following line is equivalent to

* java.util.Random random = new java.util.Random();

* It would have been incorrect without the import.

*/

Random random = new Random();

}

}

</pre></div>

Import-on-demand declarations are mentioned in the code. A "type import" imports all the types of the package. A "static import" imports members of the package.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>import java.util.*; /*This form of importing classes makes all classes

in package java.util available by name, could be used instead of the

import declaration in the previous example. */

import java.*; /*This statement is legal, but does nothing, since there

are no classes directly in package java. All of them are in packages

within package java. This does not import all available classes.*/

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Static_import_declaration">Static import declaration</h4></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Static_import" title="Static import">Static import</a></div>

This type of declaration has been available since <a href="J2SE_5.0" class="mw-redirect" title="J2SE 5.0">J2SE 5.0</a>. <a href="Static_imports" class="mw-redirect" title="Static imports">Static import</a> declarations allow access to static members defined in another class, interface, annotation, or enum; without specifying the class name:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>import static java.lang.System.out; //'out' is a static field in java.lang.System

public class HelloWorld {

/* The following line is equivalent to

System.out.println("Hi World!");

and would have been incorrect without the import declaration. */

out.println("Hello World!");

}

}

</pre></div>

Import-on-demand declarations allow to import all the fields of the type:

/* This form of declaration makes all

fields in the java.lang.System class available by name, and may be used instead

of the import declaration in the previous example. */

</pre></div>

Enum constants may also be used with static import. For example, this enum is in the package called <code>screen</code>:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public enum ColorName {

RED, BLUE, GREEN

};

</pre></div>

It is possible to use static import declarations in another class to retrieve the enum constants:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>import screen.ColorName;

import static screen.ColorName.*;

public class Dots {

/* The following line is equivalent to 'ColorName foo = ColorName.RED',

and it would have been incorrect without the static import. */

ColorName foo = RED;

void shift() {

/* The following line is equivalent to

if (foo == ColorName.RED) foo = ColorName.BLUE; */

if (foo == RED) foo = BLUE;

}

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Operators">Operators</h2></div>

Operators in Java are similar to those in <a href="C%2B%2B" title="C++">C++</a>. However, there is no <code>delete</code> operator due to <a href="Garbage_collection_(computer_science)" title="Garbage collection (computer science)">garbage collection</a> mechanisms in Java, and there are no operations on <a href="Pointer_(computer_programming)" title="Pointer (computer programming)">pointers</a> since Java does not support them. Another difference is that Java has an unsigned right shift operator (<code>>>></code>), while C's right shift operator's signedness is type-dependent. Operators in Java cannot be <a href="Operator_overloading" title="Operator overloading">overloaded</a>.

<th style="text-align: center">Precedence

</th>

<th style="text-align: center">Operator

</th>

<th style="text-align: center">Description

</th>

<th style="text-align: center">Associativity

</th></tr>

<tr>

<th rowspan="3">1

</th>

</td>

<td style="border-bottom-style: none; border-top-style: none">Method invocation

</td>

<td style="vertical-align: center" rowspan="4">Left-to-right

</td></tr>

<tr>

</td>

<td style="border-bottom-style: none; border-top-style: none">Array access

</td></tr>

<tr>

</td>

<td style="border-bottom-style: none; border-top-style: none">Class member selection

</td></tr>

<tr>

<th>2

</th>

</td>

<td style="border-bottom-style: none">Postfix increment and decrement<a href="#cite_note-1">[1]</a>

</td></tr>

<tr>

<th rowspan="5">3

</th>

</td>

<td style="border-bottom-style: none">Prefix increment and decrement

</td>

<td style="vertical-align: center" rowspan="5">Right-to-left

</td></tr>

<tr>

</td>

<td style="border-bottom-style: none; border-top-style: none">Unary plus and minus

</td></tr>

<tr>

</td>

<td style="border-bottom-style: none; border-top-style: none">Logical NOT and bitwise NOT

</td></tr>

<tr>

</td>

<td style="border-bottom-style: none; border-top-style: none">Type cast

</td></tr>

<tr>

</td>

<td style="border-top-style: none">Class instance or array creation

</td></tr>

<tr>

<th>4

</th>

</td>

<td>Multiplication, division, and modulus (remainder)

</td>

<td style="vertical-align: center" rowspan="13">Left-to-right

</td></tr>

<tr>

<th rowspan="2">5

</th>

</td>

<td style="border-bottom-style: none;">Addition and subtraction

</td></tr>

<tr>

</td>

<td style="border-top-style: none">String concatenation

</td></tr>

<tr>

<th>6

</th>

</td>

<td><a href="Bitwise_operation" title="Bitwise operation">Bitwise</a> left shift, signed right shift and unsigned right shift

</td></tr>

<tr>

<th rowspan="3">7

</th>

</td>

<td style="border-bottom-style: none;"><a href="Relational_operator" title="Relational operator">Relational</a> "less than" and "less than or equal to"

</td></tr>

<tr>

</td>

<td style="border-bottom-style: none; border-top-style: none">Relational "greater than" and "greater than or equal to"

</td></tr>

<tr>

<td style="border-top-style: none"><code>instanceof</code>

</td>

<td style="border-top-style: none">Type comparison

</td></tr>

<tr>

<th>8

</th>

</td>

<td>Relational "equal to" and "not equal to"

</td></tr>

<tr>

<th>9

</th>

</td>

<td>Bitwise and logical AND

</td></tr>

<tr>

<th>10

</th>

</td>

<td>Bitwise and logical XOR (exclusive or)

</td></tr>

<tr>

<th>11

</th>

</td>

<td>Bitwise and logical OR (inclusive or)

</td></tr>

<tr>

<th>12

</th>

</td>

<td>Logical conditional-AND

</td></tr>

<tr>

<th>13

</th>

</td>

<td>Logical conditional-OR

</td></tr>

<tr>

<th>14

</th>

</td>

<td><a href="Ternary_operator" class="mw-redirect" title="Ternary operator">Ternary</a> conditional (see <a href="%3F%3A" class="mw-redirect" title="?:">?:</a>)

</td>

<td style="vertical-align: center" rowspan="6">Right-to-left

</td></tr>

<tr>

<th rowspan="5">15

</th>

</td>

<td style="border-bottom-style: none">Simple assignment

</td></tr>

<tr>

</td>

<td style="border-bottom-style: none; border-top-style: none">Assignment by sum and difference

</td></tr>

<tr>

</td>

<td style="border-bottom-style: none; border-top-style: none">Assignment by product, quotient, and remainder

</td></tr>

<tr>

</td>

<td style="border-bottom-style: none; border-top-style: none">Assignment by bitwise left shift, signed right shift and unsigned right shift

</td></tr>

<tr>

</td>

<td style="border-top-style: none">Assignment by bitwise AND, XOR, and OR

</td></tr></tbody></table>

<div class="mw-heading mw-heading2"><h2 id="Control_structures">Control structures</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Conditional_statements">Conditional statements</h3></div>

<div class="mw-heading mw-heading4"><h4 id="if_statement"><code>if</code> statement</h4></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Conditional_(computer_programming)#C-like_languages" title="Conditional (computer programming)">Conditional (computer programming) § C-like languages</a></div>

<a href="Conditional_(computer_programming)" title="Conditional (computer programming)">if statements</a> in Java are similar to those in C and use the same syntax:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>if (i == 3) {

doSomething();

}

</pre></div>

<code>if</code> statement may include optional <code>else</code> block, in which case it becomes an if-then-else statement:

doSomething();

} else {

doSomethingElse();

}

</pre></div>

Like C, else-if construction does not involve any special keywords, it is formed as a sequence of separate if-then-else statements:

doSomething();

} else if (i == 2) {

doSomethingElse();

} else {

doSomethingDifferent();

}

</pre></div>

Also, a <a href="%3F%3A" class="mw-redirect" title="?:">?:</a> operator can be used in place of simple if statement, for example

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int a = 1;

int b = 2;

int minVal = (a < b) ? a : b;

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="switch_statement"><code>switch</code> statement</h4></div>

<a href="Switch_statement" title="Switch statement">Switch statements</a> in Java can use <code>byte</code>, <code>short</code>, <code>char</code>, and <code>int</code> (not <code>long</code>) primitive data types or their corresponding wrapper types. Starting with J2SE 5.0, it is possible to use <a href="Enumerated_type" title="Enumerated type">enum types</a>. Starting with Java SE 7, it is possible to use Strings.<a href="#cite_note-2">[2]</a> Other <a href="Reference_type" class="mw-redirect" title="Reference type">reference types</a> cannot be used in <code>switch</code> statements.

Possible values are listed using <code>case</code> labels. These labels in Java may contain only constants (including enum constants and string constants). Execution will start after the label corresponding to the expression inside the brackets. An optional <code>default</code> label may be present to declare that the code following it will be executed if none of the case labels correspond to the expression.

Code for each label ends with the <code>break</code> keyword. It is possible to omit it causing the execution to proceed to the next label, however, a warning will usually be reported during compilation.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>switch (ch) {

case 'A':

doSomething(); // Triggered if ch == 'A'

break;

case 'B':

case 'C':

doSomethingElse(); // Triggered if ch == 'B' or ch == 'C'

break;

default:

doSomethingDifferent(); // Triggered in any other case

break;

}

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="switch_expressions"><code>switch</code> expressions</h5></div>

Since Java 14 it has become possible to use switch expressions, which use the new arrow syntax:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>var result = switch (ch) {

case 'A' -> Result.GREAT;

case 'B', 'C' -> Result.FINE;

default -> throw new ThisIsNoGoodException();

};

</pre></div>

Alternatively, there is a possibility to express the same with the <code>yield</code> statement, although it is recommended to prefer the arrow syntax because it avoids the problem of accidental fall throughs.

case 'A':

yield Result.GREAT;

case 'B':

case 'C':

yield Result.FINE;

default:

throw new ThisIsNoGoodException();

};

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Iteration_statements">Iteration statements</h3></div>

Iteration statements are statements that are repeatedly executed when a given condition is evaluated as true. Since <a href="J2SE_5.0" class="mw-redirect" title="J2SE 5.0">J2SE 5.0</a>, Java has four forms of such statements. The condition must have type boolean or Boolean, meaning C's<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>while (1) {

doSomething();

}

</pre></div>results in a compilation error.

<div class="mw-heading mw-heading4"><h4 id="while_loop"><code>while</code> loop</h4></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="While_loop" title="While loop">While loop</a></div>

In the <code>while</code> loop, the test is done before each iteration.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>while (i < 10) {

doSomething();

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="do_..._while_loop"><code>do ... while</code> loop</h4></div>

In the <code>do ... while</code> loop, the test is done after each iteration. Consequently, the code is always executed at least once.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// doSomething() is called at least once

do {

doSomething();

} while (i < 10);

</pre></div>

<code>for</code> loops in Java include an initializer, a condition and a counter expression. It is possible to include several expressions of the same kind using comma as delimiter (except in the condition). However, unlike C, the comma is just a delimiter and not an operator.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>for (int i = 0; i < 10; i++) {

doSomething();

}

// A more complex loop using two variables

for (int i = 0, j = 9; i < 10; i++, j -= 3) {

doSomething();

}

</pre></div>

Like C, all three expressions are optional. The following loop is infinite:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>for (;;) {

doSomething();

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Enhanced_for_loop">Enhanced <code>for</code> loop</h4></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Enhanced_for_loop" class="mw-redirect" title="Enhanced for loop">Enhanced for loop</a></div>

<a href="Enhanced_for_loop" class="mw-redirect" title="Enhanced for loop">Enhanced <code>for</code> loops</a> have been available since <a href="J2SE_5.0" class="mw-redirect" title="J2SE 5.0">J2SE 5.0</a>. This type of loop uses built-in iterators over arrays and collections to return each item in the given collection. Every element is returned and reachable in the context of the code block. When the block is executed, the next item is returned until there are no items remaining. Unlike <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>, this kind of loop does not involve a special keyword, but instead uses a different notation style.

doSomething(i);

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Jump_statements">Jump statements</h3></div>

<div class="mw-heading mw-heading4"><h4 id="Labels">Labels</h4></div>

Labels are given points in code used by <code>break</code> and <code>continue</code> statements. The Java <code>goto</code> keyword cannot be used to jump to specific points in code.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>start:

someMethod();

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="break_statement"><code>break</code> statement</h4></div>

The <code>break</code> statement breaks out of the closest loop or <code>switch</code> statement. Execution continues in the statement after the terminated statement, if any.

while (true) {

break;

}

// Will break to this point

}

</pre></div>

It is possible to break out of the outer loop using labels:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>outer:

break outer;

}

}

// Will break to this point

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="continue_statement"><code>continue</code> statement</h4></div>

The <code>continue</code> statement discontinues the current iteration of the current control statement and begins the next iteration. The following <code>while</code> loop in the code below reads characters by calling <code>getChar()</code>, skipping the statements in the body of the loop if the characters are spaces:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int ch;

while (ch == getChar()) {

if (ch == ' ') {

continue; // Skips the rest of the while-loop

}

// Rest of the while-loop, will not be reached if ch == ' '

doSomething();

}

</pre></div>

Labels can be specified in <code>continue</code> statements and <code>break</code> statements:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>outer:

for (String str : stringsArr) {

char[] strChars = str.toCharArray();

for (char ch : strChars) {

/* Continues the outer cycle and the next

string is retrieved from stringsArr */

continue outer;

}

doSomething(ch);

}

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="return_statement"><code>return</code> statement</h4></div>

The <code>return</code> statement is used to end method execution and to return a value. A value returned by the method is written after the <code>return</code> keyword. If the method returns anything but <code>void</code>, it must use the <code>return</code> statement to return some value.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>void doSomething(boolean streamClosed) {

// If streamClosed is true, execution is stopped

if (streamClosed) {

return;

}

readFromStream();

}

int calculateSum(int a, int b) {

int result = a + b;

return result;

}

</pre></div>

<code>return</code> statement ends execution immediately, except for one case: if the statement is encountered within a <code>try</code> block and it is complemented by a <code>finally</code>, control is passed to the <code>finally</code> block.

try {

return;

}

readFromStream();

} finally {

/* Will be called last even if

readFromStream() was not called */

freeResources();

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Exception_handling_statements">Exception handling statements</h3></div>

<div class="mw-heading mw-heading4"><h4 id="try-catch-finally_statements"><code>try-catch-finally</code> statements</h4></div>

Exceptions are managed within <code>try</code> ... <code>catch</code> blocks.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>try {

// Statements that may throw exceptions

methodThrowingExceptions();

} catch (Exception ex) {

// Exception caught and handled here

reportException(ex);

} finally {

// Statements always executed after the try/catch blocks

freeResources();

}

</pre></div>

The statements within the <code>try</code> block are executed, and if any of them throws an exception, execution of the block is discontinued and the exception is handled by the <code>catch</code> block. There may be multiple <code>catch</code> blocks, in which case the first block with an exception variable whose type matches the type of the thrown exception is executed.

Java SE 7 also introduced multi-catch clauses besides uni-catch clauses. This type of catch clauses allows Java to handle different types of exceptions in a single block provided they are not subclasses of each other.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>try {

methodThrowingExceptions();

} catch (IOException | IllegalArgumentException ex) {

//Both IOException and IllegalArgumentException will be caught and handled here

reportException(ex);

}

</pre></div>

If no <code>catch</code> block matches the type of the thrown exception, the execution of the outer block (or method) containing the <code>try</code> ... <code>catch</code> statement is discontinued, and the exception is passed up and outside the containing block (or method). The exception is propagated upwards through the <a href="Call_stack" title="Call stack">call stack</a> until a matching <code>catch</code> block is found within one of the currently active methods. If the exception propagates all the way up to the top-most <code>main</code> method without a matching <code>catch</code> block being found, a textual description of the exception is written to the standard output stream.

The statements within the <code>finally</code> block are always executed after the <code>try</code> and <code>catch</code> blocks, whether or not an exception was thrown and even if a <code>return</code> statement was reached. Such blocks are useful for providing cleanup code that is guaranteed to always be executed.

The <code>catch</code> and <code>finally</code> blocks are optional, but at least one or the other must be present following the <code>try</code> block.

<div class="mw-heading mw-heading4"><h4 id="try-with-resources_statements"><code>try</code>-with-resources statements</h4></div>

<code>try</code>-with-resources statements are a special type of <code>try-catch-finally</code> statements introduced as an implementation of the <a href="Dispose_pattern" title="Dispose pattern">dispose pattern</a> in Java SE 7. In a <code>try</code>-with-resources statement the <code>try</code> keyword is followed by initialization of one or more resources that are released automatically when the <code>try</code> block execution is finished. Resources must implement <code>java.lang.AutoCloseable</code>. <code>try</code>-with-resources statements are not required to have a <code>catch</code> or <code>finally</code> block unlike normal <code>try-catch-finally</code> statements.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>try (FileOutputStream fos = new FileOutputStream("filename");

XMLEncoder xEnc = new XMLEncoder(fos)) {

xEnc.writeObject(object);

} catch (IOException ex) {

Logger.getLogger(Serializer.class.getName()).log(Level.SEVERE, null, ex);

}

</pre></div>

Since Java 9 it is possible to use already declared variables:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>FileOutputStream fos = new FileOutputStream("filename");

XMLEncoder xEnc = new XMLEncoder(fos);

try (fos; xEnc) {

xEnc.writeObject(object);

} catch (IOException ex) {

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="throw_statement"><code>throw</code> statement</h4></div>

The <code>throw</code> statement is used to throw an exception and end the execution of the block or method. The thrown exception instance is written after the <code>throw</code> statement.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>void methodThrowingExceptions(Object obj) {

if (obj == null) {

// Throws exception of NullPointerException type

throw new NullPointerException();

}

// Will not be called, if object is null

doSomethingWithObject(obj);

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Thread_concurrency_control">Thread concurrency control</h3></div>

Java has built-in tools for <a href="Thread_(computing)" title="Thread (computing)">multi-thread programming</a>. For the purposes of thread <a href="Synchronization_(computer_science)" title="Synchronization (computer science)">synchronization</a> the <code>synchronized</code> statement is included in Java language.

To make a code block synchronized, it is preceded by the <code>synchronized</code> keyword followed by the lock object inside the brackets. When the executing thread reaches the synchronized block, it acquires a <a href="Mutual_exclusion" title="Mutual exclusion">mutual exclusion</a> lock, executes the block, then releases the lock. No threads may enter this block until the lock is released. Any non-null reference type may be used as the lock.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>/* Acquires lock on someObject. It must be of

a reference type and must be non-null */

synchronized (someObject) {

// Synchronized statements

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="assert_statement"><code>assert</code> statement</h3></div>

<code>assert</code> statements have been available since <a href="J2SE_1.4" class="mw-redirect" title="J2SE 1.4">J2SE 1.4</a>. These types of statements are used to make <a href="Assertion_(computing)" class="mw-redirect" title="Assertion (computing)">assertions</a> in the source code, which can be turned on and off during execution for specific classes or packages. To declare an assertion the <code>assert</code> keyword is used followed by a conditional expression. If it evaluates to <code>false</code> when the statement is executed, an exception is thrown. This statement can include a colon followed by another expression, which will act as the exception's detail message.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// If n equals 0, AssertionError is thrown

assert n != 0;

/* If n equals 0, AssertionError will be thrown

with the message after the colon */

assert n != 0 : "n was equal to zero";

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Primitive_types">Primitive types</h2></div>

Primitive types in Java include integer types, floating-point numbers, <a href="UTF-16" title="UTF-16">UTF-16</a> code units and a Boolean type. There are no unsigned types in Java except <code>char</code> type, which is used to represent UTF-16 code units. The lack of unsigned types is offset by introducing unsigned right shift operation (<code>>>></code>), which is not present in C++. Nevertheless, criticisms have been leveled about the lack of compatibility with C and C++ this causes.<a href="#cite_note-3">[3]</a>

<th colspan="6">Primitive Types

</th></tr>

<tr>

<th>Type Name

</th>

<th><a href="Primitive_wrapper_class_in_Java" title="Primitive wrapper class in Java">Wrapper class</a>

</th>

<th>Value

</th>

<th>Range

</th>

<th>Size

</th>

<th>Default Value

</th></tr>

<tr>

</td>

</td>

<td>integer

</td>

<td>−128 through +127

</td>

<td>8-bit (1-byte)

</td>

</td></tr>

<tr>

<td><code>short</code>

</td>

<td><code>java.lang.Short</code>

</td>

<td>integer

</td>

<td>−32,768 through +32,767

</td>

<td>16-bit (2-byte)

</td>

</td></tr>

<tr>

</td>

<td><code>java.lang.Integer</code>

</td>

<td>integer

</td>

<td>−2,147,483,648 through +2,147,483,647

</td>

<td>32-bit (4-byte)

</td>

</td></tr>

<tr>

</td>

</td>

<td>integer

</td>

<td>−9,223,372,036,854,775,808 through +9,223,372,036,854,775,807

</td>

<td>64-bit (8-byte)

</td>

</td></tr>

<tr>

<td><code>float</code>

</td>

<td><code>java.lang.Float</code>

</td>

<td>floating point number

</td>

<td>±1.401298E−45 through ±3.402823E+38

</td>

<td>32-bit (4-byte)

</td>

</td></tr>

<tr>

<td><code>double</code>

</td>

<td><code>java.lang.Double</code>

</td>

<td>floating point number

</td>

<td>±4.94065645841246E−324 through ±1.79769313486232E+308

</td>

<td>64-bit (8-byte)

</td>

</td></tr>

<tr>

<td><code>boolean</code>

</td>

<td><code>java.lang.Boolean</code>

</td>

<td>Boolean

</td>

<td><code>true</code> or <code>false</code>

</td>

<td>1-bit (1-bit)

</td>

<td><code>false</code>

</td></tr>

<tr>

</td>

<td><code>java.lang.Character</code>

</td>

<td><a href="UTF-16" title="UTF-16">UTF-16</a> code unit (<a href="Mapping_of_Unicode_character_planes" class="mw-redirect" title="Mapping of Unicode character planes">BMP</a> character or a part of a surrogate pair)

</td>

<td><code>'\u0000'</code> through <code>'\uFFFF'</code>

</td>

<td>16-bit (2-byte)

</td>

</td></tr></tbody></table>

<code>char</code> does not necessarily correspond to a single character. It may represent a part of a <a href="UTF-16#Encoding_of_characters_outside_the_BMP" title="UTF-16">surrogate pair</a>, in which case Unicode code point is represented by a sequence of two <code>char</code> values.

<div class="mw-heading mw-heading3"><h3 id="Boxing_and_unboxing">Boxing and unboxing</h3></div>

This language feature was introduced in <a href="J2SE_5.0" class="mw-redirect" title="J2SE 5.0">J2SE 5.0</a>. Boxing is the operation of converting a value of a primitive type into a value of a corresponding reference type, which serves as a wrapper for this particular primitive type. Unboxing is the reverse operation of converting a value of a reference type (previously boxed) into a value of a corresponding primitive type. Neither operation requires an explicit conversion.

Example:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int foo = 42; // Primitive type

Integer bar = foo; /* foo is boxed to bar, bar is of Integer type,

which serves as a wrapper for int */

int foo2 = bar; // Unboxed back to primitive type

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Reference_types">Reference types</h2></div>

Reference types include class types, interface types, and array types. When the constructor is called, an object is created on the heap and a reference is assigned to the variable. When a variable of an object gets out of scope, the reference is broken and when there are no references left, the object gets marked as garbage. The garbage collector then collects and destroys it some time afterwards.

A reference variable is <code>null</code> when it does not reference any object.

<div class="mw-heading mw-heading3"><h3 id="Arrays">Arrays</h3></div>

Arrays in Java are created at runtime, just like class instances. Array length is defined at creation and cannot be changed.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int[] numbers = new int[5];

int x = numbers[0];

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Initializers">Initializers</h4></div>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// Long syntax

int[] numbers = new int[] {20, 1, 42, 15, 34};

// Short syntax

int[] numbers2 = {20, 1, 42, 15, 34};

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Multi-dimensional_arrays">Multi-dimensional arrays</h4></div>

In Java, multi-dimensional arrays are represented as arrays of arrays. Technically, they are represented by arrays of references to other arrays.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int[][] numbers = new int[3][3];

numbers[1][2] = 2;

int[][] numbers2 = {{2, 3, 2}, {1, 2, 6}, {2, 4, 5}};

</pre></div>

Due to the nature of the multi-dimensional arrays, sub-arrays can vary in length, so multi-dimensional arrays are not bound to be rectangular unlike C:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int[][] numbers = new int[2][]; //Initialization of the first dimension only

numbers[0] = new int[3];

numbers[1] = new int[2];

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Classes">Classes</h3></div>

<a href="Class_(computer_programming)" title="Class (computer programming)">Classes</a> are fundamentals of an object-oriented language such as Java. They contain members that store and manipulate data. Classes are divided into top-level and nested. Nested classes are classes placed inside another class that may access the private members of the enclosing class. Nested classes include member classes (which may be defined with the static modifier for simple nesting or without it for inner classes), local classes and anonymous classes.

<div class="mw-heading mw-heading4"><h4 id="Declaration">Declaration</h4></div>

<th>Top-level class

</th>

<td><div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

// Class members

}

</pre></div>

</td></tr>

<tr>

<th>Inner class

</th>

<td><div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo { // Top-level class

class Bar { // Inner class

}

}

</pre></div>

</td></tr>

<tr>

<th>Nested class

</th>

static class Bar { // Nested class

}

}

</pre></div>

</td></tr>

<tr>

<th>Local class

</th>

<td><div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

void bar() {

class Foobar {// Local class within a method

}

}

</pre></div>

</td></tr>

<tr>

<th>Anonymous class

</th>

<td><div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

void bar() {

new Object() {// Creation of a new anonymous class extending Object

};

}

}

</pre></div>

</td></tr></tbody></table>

<div class="mw-heading mw-heading4"><h4 id="Instantiation">Instantiation</h4></div>

Non-static members of a class define the types of the <a href="Instance_variable" title="Instance variable">instance variables</a> and methods, which are related to the objects created from that class. To create these objects, the class must be instantiated by using the <code>new</code> operator and calling the class constructor.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>Foo foo = new Foo();

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Accessing_members">Accessing members</h4></div>

Members of both instances and static classes are accessed with the <code>.</code> (dot) operator.

Accessing an instance member

Instance members can be accessed through the name of a variable.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>String foo = "Hello";

String bar = foo.toUpperCase();

</pre></div>

Accessing a static class member

Static members are accessed by using the name of the class or any other type. This does not require the creation of a class instance. Static members are declared using the <code>static</code> modifier.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public class Foo {

public static void doSomething() {

}

}

// Calling the static method

Foo.doSomething();

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Modifiers">Modifiers</h4></div>

Modifiers are keywords used to modify declarations of types and type members. Most notably there is a sub-group containing the access modifiers.

<ul><li><code>abstract</code> - Specifies that a class only serves as a base class and cannot be instantiated.</li>

<li><code>static</code> - Used only for member classes, specifies that the member class does not belong to a specific instance of the containing class.</li>

<li><code>final</code> - Classes marked as <code>final</code> cannot be extended from and cannot have any subclasses.</li>

<li><code>strictfp</code> - Specifies that all floating-point operations must be carried out conforming to <a href="IEEE_754" title="IEEE 754">IEEE 754</a> and forbids using enhanced precision to store intermediate results.</li></ul>

<div class="mw-heading mw-heading5"><h5 id="Abstract_class">Abstract class</h5></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .excerpt-hat .mw-editsection-like{font-style:normal}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable dablink excerpt-hat selfref">This section is an excerpt from <a href="Abstract_type#Java" title="Abstract type">Abstract type § Java</a>.[<a class="external text external" href="https://en.wikipedia.org/w/index.php?title=Abstract_type&action=edit#Java">edit</a>]</div><div class="excerpt">

By default, all methods in all classes are concrete, unless the abstract keyword is used. An abstract class may include abstract methods, which have no implementation.

By default, all methods in all interfaces are abstract, unless the default keyword is used.

The default keyword can be used to specify a concrete method in an interface.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>//By default, all methods in all classes are concrete, unless the abstract keyword is used.

public abstract class Demo {

// An abstract class may include abstract methods, which have no implementation.

public abstract int sum(int x, int y);

// An abstract class may also include concrete methods.

public int product(int x, int y) {

return x*y;

}

}

//By default, all methods in all interfaces are abstract, unless the default keyword is used.

interface DemoInterface {

int getLength(); //The abstract keyword can be used here, though is completely useless

//The default keyword can be used in this context to specify a concrete method in an interface

default int product(int x, int y) {

return x * y;

}

}

</pre></div>

</div></div>

<div class="mw-heading mw-heading5"><h5 id="Final_class">Final class</h5></div>

<div class="excerpt-block"><div role="note" class="hatnote navigation-not-searchable dablink excerpt-hat selfref">This section is an excerpt from <a href="Final_(Java)#Final_classes" title="Final (Java)">Final (Java) § Final classes</a>.[<a class="external text external" href="https://en.wikipedia.org/w/index.php?title=Final_(Java)&action=edit#Final_classes">edit</a>]</div><div class="excerpt">

A final <a href="Class_(computer_science)" class="mw-redirect" title="Class (computer science)">class</a> cannot be subclassed. As doing this can confer security and efficiency benefits, many of the Java standard library classes are final, such as <code><a rel="nofollow" class="external text" href="https://docs.oracle.com/en/java/javase/24/docs/api/java.base/java/lang/System.html">java.lang.System</a></code> and <code><a rel="nofollow" class="external text" href="https://docs.oracle.com/en/java/javase/24/docs/api/java.base/java/lang/String.html">java.lang.String</a></code>.

Example:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public final class MyFinalClass {...}

public class ThisIsWrong extends MyFinalClass {...} // forbidden

</pre></div></div></div>

<div class="mw-heading mw-heading5"><h5 id="Access_modifiers">Access modifiers</h5></div>

The access modifiers, or inheritance modifiers, set the accessibility of classes, methods, and other members. Members marked as <code>public</code> can be reached from anywhere. If a class or its member does not have any modifiers, default access is assumed.

int go() {

return 0;

}

private class Bar {

}

}

</pre></div>

The following table shows whether code within a class has access to the class or method depending on the accessing class location and the modifier for the accessed class or class member:

<th width="20%">Modifier

</th>

<th width="20%">Same class or nested class

</th>

<th width="20%">Other class inside the same package

</th>

<th width="20%">Extended Class inside another package

</th>

<th width="20%">Non-extended inside another package

</th></tr>

<tr>

<th><code>private</code>

</th>

<td>yes

</td>

<td>no

</td>

<td>no

</td>

<td>no

</td></tr>

<tr>

<th>default (package private)

</th>

<td>yes

</td>

<td>yes

</td>

<td>no

</td>

<td>no

</td></tr>

<tr>

<th><code>protected</code>

</th>

<td>yes

</td>

<td>yes

</td>

<td>yes

</td>

<td>no

</td></tr>

<tr>

<th><code>public</code>

</th>

<td>yes

</td>

<td>yes

</td>

<td>yes

</td>

<td>yes

</td></tr>

</tbody></table>

<div class="mw-heading mw-heading4"><h4 id="Constructors_and_initializers">Constructors and initializers</h4></div>

A <a href="Constructor_(object-oriented_programming)" title="Constructor (object-oriented programming)">constructor</a> is a special method called when an object is initialized. Its purpose is to initialize the members of the object. The main differences between constructors and ordinary methods are that constructors are called only when an instance of the class is created and never return anything. Constructors are declared as common methods, but they are named after the class and no return type is specified:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

String str;

Foo() { // Constructor with no arguments

// Initialization

}

Foo(String str) { // Constructor with one argument

this.str = str;

}

}

</pre></div>

Initializers are blocks of code that are executed when a class or an instance of a class is created. There are two kinds of initializers, static initializers and instance initializers.

Static initializers initialize static fields when the class is created. They are declared using the <code>static</code> keyword:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

static {

// Initialization

}

}

</pre></div>

A class is created only once. Therefore, static initializers are not called more than once. On the contrary, instance initializers are automatically called before the call to a constructor every time an instance of the class is created. Unlike constructors instance initializers cannot take any arguments and generally they cannot throw any <a href="Exception_handling#Checked_exceptions" title="Exception handling">checked exceptions</a> (except in several special cases). Instance initializers are declared in a block without any keywords:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

{

// Initialization

}

}

</pre></div>

Since Java has a garbage collection mechanism, there are no <a href="Destructor_(computer_science)" class="mw-redirect" title="Destructor (computer science)">destructors</a>. However, every object has a <code>finalize()</code> method called prior to garbage collection, which can be <a href="Method_overriding" title="Method overriding">overridden</a> to implement finalization.

<div class="mw-heading mw-heading4"><h4 id="Methods">Methods</h4></div>

All the statements in Java must reside within <a href="Method_(computer_programming)" title="Method (computer programming)">methods</a>. Methods are similar to functions except they belong to classes. A method has a return value, a name and usually some parameters initialized when it is called with some arguments. Similar to C++, methods returning nothing have return type declared as <code>void</code>. Unlike in C++, methods in Java are not allowed to have <a href="Default_argument" title="Default argument">default argument</a> values and methods are usually overloaded instead.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

int bar(int a, int b) {

return (a*2) + b;

}

/* Overloaded method with the same name but different set of arguments */

return a*2;

}

}

</pre></div>

A method is called using <code>.</code> notation on an object, or in the case of a static method, also on the name of a class.

int result = foo.bar(7, 2); // Non-static method is called on foo

int finalResult = Math.abs(result); // Static method call

</pre></div>

The <code>throws</code> keyword indicates that a method throws an exception. All checked exceptions must be listed in a comma-separated list.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>void openStream() throws IOException, myException { // Indicates that IOException may be thrown

}

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Modifiers_2">Modifiers</h5></div>

<ul><li><code>abstract</code> - <a href="Abstract_method" class="mw-redirect" title="Abstract method">Abstract methods</a> can be present only in <a href="Abstract_class" class="mw-redirect" title="Abstract class">abstract classes</a>, such methods have no body and must be overridden in a subclass unless it is abstract itself.</li>

<li><code>static</code> - Makes the method static and accessible without creation of a class instance. However static methods cannot access non-static members in the same class.</li>

<li><code>final</code> - Declares that the method cannot be overridden in a subclass.</li>

<li><code>native</code> - Indicates that this method is implemented through <a href="JNI" class="mw-redirect" title="JNI">JNI</a> in platform-dependent code. Actual implementation happens outside Java code, and such methods have no body.</li>

<li><code>strictfp</code> - Declares strict conformance to <a href="IEEE_754" title="IEEE 754">IEEE 754</a> in carrying out floating-point operations.</li>

<li><code>synchronized</code> - Declares that a thread executing this method must acquire monitor. For <code>synchronized</code> methods the monitor is the class instance or <code>java.lang.Class</code> if the method is static.</li>

<li>Access modifiers - Identical to those used with classes.</li></ul>

<div class="mw-heading mw-heading6"><h6 id="Final_methods">Final methods</h6></div>

<div class="excerpt-block"><div role="note" class="hatnote navigation-not-searchable dablink excerpt-hat selfref">This section is an excerpt from <a href="Final_(Java)#Final_methods" title="Final (Java)">Final (Java) § Final methods</a>.[<a class="external text external" href="https://en.wikipedia.org/w/index.php?title=Final_(Java)&action=edit#Final_methods">edit</a>]</div><div class="excerpt">

A final <a href="Method_(computer_science)" class="mw-redirect" title="Method (computer science)">method</a> cannot be <a href="Method_overriding" title="Method overriding">overridden</a> or hidden by subclasses.<a href="#cite_note-5">[5]</a> This is used to prevent unexpected behavior from a subclass altering a method that may be crucial to the function or consistency of the class.<a href="#cite_note-6">[6]</a>

Example:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public class Base

{

public void m1() {...}

public final void m2() {...}

public static final void m4() {...}

}

public class Derived extends Base

{

public void m2() {...} // forbidden

public static void m3() {...} // OK, hiding Base#m3()

public static void m4() {...} // forbidden

}

</pre></div>

A common misconception is that declaring a method as <code>final</code> improves efficiency by allowing the compiler to directly insert the method wherever it is called (see <a href="Inline_expansion" title="Inline expansion">inline expansion</a>). Because the method is loaded at <a href="Run_time_(program_lifecycle_phase)" class="mw-redirect" title="Run time (program lifecycle phase)">runtime</a>, compilers are unable to do this. Only the runtime environment and <a href="Just-in-time_compilation" title="Just-in-time compilation">JIT</a> compiler know exactly which classes have been loaded, and so only they are able to make decisions about when to inline, whether or not the method is final.<a href="#cite_note-7">[7]</a>

Machine code compilers that generate directly executable, platform-specific <a href="Machine_code" title="Machine code">machine code</a>, are an exception. When using <a href="Static_linking" class="mw-redirect" title="Static linking">static linking</a>, the compiler can safely assume that methods and variables computable at <a href="Compile-time" class="mw-redirect" title="Compile-time">compile-time</a> may be inlined.</div></div>

<div class="mw-heading mw-heading5"><h5 id="Varargs">Varargs</h5></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Variadic_function#In_Java" title="Variadic function">Variadic function § In Java</a></div>

This language feature was introduced in <a href="J2SE_5.0" class="mw-redirect" title="J2SE 5.0">J2SE 5.0</a>. The last argument of the method may be declared as a variable arity parameter, in which case the method becomes a variable arity method (as opposed to fixed arity methods) or simply <a href="Variadic_function" title="Variadic function">varargs</a> method. This allows one to pass a variable number of values, of the declared type, to the method as parameters - including no parameters. These values will be available inside the method as an array.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>void printReport(String header, int... numbers) { //numbers represents varargs

for (int num : numbers) {

}

}

// Calling varargs method

printReport("Report data", 74, 83, 25, 96);

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Fields">Fields</h4></div>

Fields, or <a href="Class_variable" title="Class variable">class variables</a>, can be declared inside the class body to store data.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

double bar;

}

</pre></div>

Fields can be initialized directly when declared.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

double bar = 2.3;

}

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Modifiers_3">Modifiers</h5></div>

<ul><li><code>static</code> - Makes the field a static member.</li>

<li><code>final</code> - Allows the field to be initialized only once in a constructor or inside initialization block or during its declaration, whichever is earlier.</li>

<li><code>transient</code> - Indicates that this field will not be stored during <a href="Serialization" title="Serialization">serialization</a>.</li>

<li><code>volatile</code> - If a field is declared <code>volatile</code>, it is ensured that all threads see a consistent value for the variable.</li></ul>

<div class="mw-heading mw-heading4"><h4 id="Inheritance">Inheritance</h4></div>

Classes in Java can only <a href="Inheritance_(object-oriented_programming)" title="Inheritance (object-oriented programming)">inherit</a> from one class. A class can be derived from any class that is not marked as <code>final</code>. Inheritance is declared using the <code>extends</code> keyword. A class can reference itself using the <code>this</code> keyword and its direct superclass using the <code>super</code> keyword.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

}

class Foobar extends Foo {

}

</pre></div>

If a class does not specify its superclass, it implicitly inherits from <code>java.lang.Object</code> class. Thus all classes in Java are subclasses of <code>Object</code> class.

If the superclass does not have a constructor without parameters the subclass must specify in its constructors what constructor of the superclass to use. For example:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Foo {

public Foo(int n) {

// Do something with n

}

}

private int number;

// Superclass does not have constructor without parameters

// so we have to specify what constructor of our superclass to use and how

public Foobar(int number) {

super(number);

this.number = number;

}

}

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Overriding_methods">Overriding methods</h5></div>

Unlike C++, all non-<code>final</code> methods in Java are <a href="Virtual_function" title="Virtual function">virtual</a> and can be overridden by the inheriting classes.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Operation {

public int doSomething() {

return 0;

}

}

class NewOperation extends Operation {

@Override

return 1;

}

}

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Abstract_classes">Abstract classes</h5></div>

An <a rel="nofollow" class="external text" href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.1.1.1">Abstract Class</a> is a class that is incomplete, or is to be considered incomplete, so cannot be instantiated.

A class C has abstract methods if any of the following is true:

<ul><li>C explicitly contains a declaration of an abstract method.</li>

<li>Any of C's superclasses has an abstract method and C neither declares nor inherits a method that implements it.</li>

<li>A direct superinterface of C declares or inherits a method (which is therefore necessarily abstract) and C neither declares nor inherits a method that implements it.</li>

<li>A subclass of an abstract class that is not itself abstract may be instantiated, resulting in the execution of a constructor for the abstract class and, therefore, the execution of the field initializers for instance variables of that class.</li></ul>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>package org.dwwwp.test;

/**

* @author jcrypto

*/

public class AbstractClass {

private static final String hello;

static {

System.out.println(AbstractClass.class.getName() + ": static block runtime");

hello = "hello from " + AbstractClass.class.getName();

}

{

System.out.println(AbstractClass.class.getName() + ": instance block runtime");

}

public AbstractClass() {

System.out.println(AbstractClass.class.getName() + ": constructor runtime");

}

}

</pre></div>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>package org.dwwwp.test;

/**

* @author jcrypto

*/

public class CustomClass extends AbstractClass {

static {

System.out.println(CustomClass.class.getName() + ": static block runtime");

}

{

System.out.println(CustomClass.class.getName() + ": instance block runtime");

}

public CustomClass() {

System.out.println(CustomClass.class.getName() + ": constructor runtime");

}

CustomClass nc = new CustomClass();

hello();

//AbstractClass.hello();//also valid

}

}

</pre></div>

Output:

<div class="mw-highlight mw-highlight-lang-text mw-content-ltr" dir="ltr"><pre>org.dwwwp.test.AbstractClass: static block runtime

org.dwwwp.test.CustomClass: static block runtime

org.dwwwp.test.AbstractClass: instance block runtime

org.dwwwp.test.AbstractClass: constructor runtime

org.dwwwp.test.CustomClass: instance block runtime

org.dwwwp.test.CustomClass: constructor runtime

hello from org.dwwwp.test.AbstractClass

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Enumerations">Enumerations</h4></div>

This language feature was introduced in <a href="J2SE_5.0" class="mw-redirect" title="J2SE 5.0">J2SE 5.0</a>. Technically enumerations are a kind of class containing enum constants in its body. Each enum constant defines an instance of the enum type. Enumeration classes cannot be instantiated anywhere except in the enumeration class itself.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>enum Season {

WINTER, SPRING, SUMMER, AUTUMN

}

</pre></div>

Enum constants are allowed to have constructors, which are called when the class is loaded:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public enum Season {

WINTER("Cold"), SPRING("Warmer"), SUMMER("Hot"), AUTUMN("Cooler");

Season(String description) {

this.description = description;

}

private final String description;

public String getDescription() {

return description;

}

}

</pre></div>

Enumerations can have class bodies, in which case they are treated like anonymous classes extending the enum class:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public enum Season {

WINTER {

String getDescription() {return "cold";}

},

SPRING {

},

SUMMER {

},

FALL {

};

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Interfaces">Interfaces</h3></div>

<a href="Interface_(Java)" title="Interface (Java)">Interfaces</a> are types which contain no fields and usually define a number of methods without an actual implementation. They are useful to define a contract with any number of different implementations. Every interface is implicitly abstract. Interface methods are allowed to have a subset of access modifiers depending on the language version, <code>strictfp</code>, which has the same effect as for classes, and also <code>static</code> since Java SE 8.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>interface ActionListener {

int ACTION_ADD = 0;

int ACTION_REMOVE = 1;

void actionSelected(int action);

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Implementing_an_interface">Implementing an interface</h4></div>

An interface is implemented by a class using the <code>implements</code> keyword. It is allowed to implement more than one interface, in which case they are written after <code>implements</code> keyword in a comma-separated list. A class implementing an interface must override all its methods, otherwise it must be declared as abstract.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>interface RequestListener {

int requestReceived();

}

class ActionHandler implements ActionListener, RequestListener {

public void actionSelected(int action) {

}

public int requestReceived() {

}

}

//Calling method defined by interface

RequestListener listener = new ActionHandler(); /*ActionHandler can be

represented as RequestListener...*/

listener.requestReceived(); /*...and thus is known to implement

requestReceived() method*/

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Functional_interfaces_and_lambda_expressions">Functional interfaces and lambda expressions</h4></div>

These features were introduced with the release of Java SE 8. An interface automatically becomes a functional interface if it defines only one method. In this case an implementation can be represented as a lambda expression instead of implementing it in a new class, thus greatly simplifying writing code in the <a href="Functional_programming" title="Functional programming">functional style</a>. Functional interfaces can optionally be annotated with the <code><a href="%40FunctionalInterface" class="mw-redirect" title="@FunctionalInterface">@FunctionalInterface</a></code> annotation, which will tell the compiler to check whether the interface actually conforms to a definition of a functional interface.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// A functional interface

@FunctionalInterface

interface Calculation {

int calculate(int someNumber, int someOtherNumber);

}

// A method which accepts this interface as a parameter

int runCalculation(Calculation calculation) {

return calculation.calculate(1, 2);

}

// Using a lambda to call the method

runCalculation((number, otherNumber) -> number + otherNumber);

// Equivalent code which uses an anonymous class instead

runCalculation(new Calculation() {

@Override

public int calculate(int someNumber, int someOtherNumber) {

return someNumber + someOtherNumber;

}

})

</pre></div>

Lambda's parameters types do not have to be fully specified and can be inferred from the interface it implements. Lambda's body can be written without a body block and a <code>return</code> statement if it is only an expression. Also, for those interfaces which only have a single parameter in the method, round brackets can be omitted.<a href="#cite_note-8">[8]</a>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// Same call as above, but with fully specified types and a body block

runCalculation((int number, int otherNumber) -> {

return number + otherNumber;

});

// A functional interface with a method which has only a single parameter

interface StringExtender {

String extendString(String input);

}

// Initializing a variable of this type by using a lambda

StringExtender extender = input -> input + " Extended";

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Method_references">Method references</h4></div>

It is not necessary to use lambdas when there already is a named method compatible with the interface. This method can be passed instead of a lambda using a method reference. There are several types of method references:

<th>Reference type</th>

<th>Example</th>

<th>Equivalent lambda

</th></tr>

<tr>

<td>Static</td>

<td><code>Integer::sum</code></td>

<td><code>(number, otherNumber) -> number + otherNumber</code>

</td></tr>

<tr>

<td>Bound</td>

<td><code>"LongString"::substring</code></td>

<td><code>index -> "LongString".substring(index)</code>

</td></tr>

<tr>

<td>Unbound</td>

<td><code>String::isEmpty</code></td>

<td><code>string -> string.isEmpty()</code>

</td></tr>

<tr>

<td>Class constructor</td>

<td><code>ArrayList<String>::new</code></td>

<td><code>capacity -> new ArrayList<String>(capacity)</code>

</td></tr>

<tr>

<td>Array constructor</td>

<td><code>String[]::new</code></td>

<td><code>size -> new String[size]</code>

</td></tr></tbody></table>

The code above which calls <code>runCalculation</code> could be replaced with the following using the method references:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>runCalculation(Integer::sum);

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Inheritance_2">Inheritance</h4></div>

Interfaces can inherit from other interfaces just like classes. Unlike classes it is allowed to inherit from multiple interfaces. However, it is possible that several interfaces have a field with the same name, in which case it becomes a single ambiguous member, which cannot be accessed.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>/* Class implementing this interface must implement methods of both

ActionListener and RequestListener */

interface EventListener extends ActionListener, RequestListener {

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Default_methods">Default methods</h4></div>

Java SE 8 introduced default methods to interfaces which allows developers to add new methods to existing interfaces without breaking compatibility with the classes already implementing the interface. Unlike regular interface methods, default methods have a body which will get called in the case if the implementing class does not override it.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>interface StringManipulator {

// A method which is optional to implement

default String shortenString(String input) {

return input.substring(1);

}

}

// This is a valid class despite not implementing all the methods

class PartialStringManipulator implements StringManipulator {

@Override

public String extendString(String input) {

return input + " Extended";

}

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Static_methods">Static methods</h4></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Method_(computer_programming)#Static_methods" title="Method (computer programming)">Method (computer programming) § Static methods</a></div>

Static methods is another language feature introduced in Java SE 8. They behave in exactly the same way as in the classes.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>interface StringUtils {

static String shortenByOneSymbol(String input) {

}

}

StringUtils.shortenByOneSymbol("Test");

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Private_methods">Private methods</h4></div>

Private methods were added in the Java 9 release. An interface can have a method with a body marked as private, in which case it will not be visible to inheriting classes. It can be called from default methods for the purposes of code reuse.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>interface Logger {

default void logError() {

log(Level.ERROR);

}

default void logInfo() {

log(Level.INFO);

}

private void log(Level level) {

SystemLogger.log(level.id);

}

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Annotations">Annotations</h4></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Java_annotation" title="Java annotation">Java annotation</a></div>

Annotations in Java are a way to embed <a href="Metadata" title="Metadata">metadata</a> into code. This language feature was introduced in <a href="J2SE_5.0" class="mw-redirect" title="J2SE 5.0">J2SE 5.0</a>.

<div class="mw-heading mw-heading5"><h5 id="Annotation_types">Annotation types</h5></div>

Java has a set of predefined annotation types, but it is allowed to define new ones. An annotation type declaration is a special type of an interface declaration. They are declared in the same way as the interfaces, except the <code>interface</code> keyword is preceded by the <code>@</code> sign. All annotations are implicitly extended from <code>java.lang.annotation.Annotation</code> and cannot be extended from anything else.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>@interface BlockingOperations {

}

</pre></div>

Annotations may have the same declarations in the body as the common interfaces, in addition they are allowed to include enums and annotations. The main difference is that abstract method declarations must not have any parameters or throw any exceptions. Also they may have a default value, which is declared using the <code>default</code> keyword after the method name:

boolean fileSystemOperations();

boolean networkOperations() default false;

}

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Usage_of_annotations">Usage of annotations</h5></div>

Annotations may be used in any kind of declaration, whether it is package, class (including enums), interface (including annotations), field, method, parameter, constructor, or local variable. Also they can be used with enum constants. Annotations are declared using the <code>@</code> sign preceding annotation type name, after which element-value pairs are written inside brackets. All elements with no default value must be assigned a value.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>@BlockingOperations(/*mandatory*/ fileSystemOperations,

/*optional*/ networkOperations = true)

void openOutputStream() { //Annotated method

}

</pre></div>

Besides the generic form, there are two other forms to declare an annotation, which are shorthands. Marker annotation is a short form, it is used when no values are assigned to elements:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>@Unused // Shorthand for @Unused()

void travelToJupiter() {

}

</pre></div>

The other short form is called single element annotation. It is used with annotations types containing only one element or in the case when multiple elements are present, but only one elements lacks a default value. In single element annotation form the element name is omitted and only value is written instead:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>/* Equivalent for @BlockingOperations(fileSystemOperations = true).

networkOperations has a default value and

does not have to be assigned a value */

@BlockingOperations(true)

void openOutputStream() {

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Generics">Generics</h2></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Generics_in_Java" title="Generics in Java">Generics in Java</a></div>

<a href="Generic_programming" title="Generic programming">Generics</a>, or parameterized types, or <a href="Parametric_polymorphism" title="Parametric polymorphism">parametric polymorphism</a>, is one of the major features introduced in <a href="J2SE_5.0" class="mw-redirect" title="J2SE 5.0">J2SE 5.0</a>. Before generics were introduced, it was required to declare all the types explicitly. With generics, it became possible to work in a similar manner with different types without declaring the exact types. The main purpose of generics is to ensure type safety and to detect runtime errors during compilation. Unlike C#, information on the used parameters is not available at runtime due to <a href="Type_erasure" title="Type erasure">type erasure</a>.<a href="#cite_note-9">[9]</a>

<div class="mw-heading mw-heading3"><h3 id="Generic_classes">Generic classes</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Generics_in_Java#Generic_class_definitions" title="Generics in Java">Generics in Java § Generic class definitions</a></div>

Classes can be parameterized by adding a type variable inside angle brackets (<code><</code> and <code>></code>) following the class name. It makes possible the use of this type variable in class members instead of actual types. There can be more than one type variable, in which case they are declared in a comma-separated list.

It is possible to limit a type variable to a subtype of some specific class or declare an interface that must be implemented by the type. In this case the type variable is appended by the <code>extends</code> keyword followed by a name of the class or the interface. If the variable is constrained by both class and interface or if there are several interfaces, the class name is written first, followed by interface names with <code>& </code> sign used as the delimiter.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>/* This class has two type variables, T and V. T must be

a subtype of ArrayList and implement Formattable interface */

public class Mapper<T extends ArrayList & Formattable, V> {

public void add(T array, V item) {

// array has add method because it is an ArrayList subclass

array.add(item);

}

}

</pre></div>

When a variable of a parameterized type is declared or an instance is created, its type is written exactly in the same format as in the class header, except the actual type is written in the place of the type variable declaration.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>/* Mapper is created with CustomList as T and Integer as V.

CustomList must be a subclass of ArrayList and implement Formattable */

Mapper<CustomList, Integer> mapper = new Mapper<CustomList, Integer>();

</pre></div>

Since Java SE 7, it is possible to use a diamond (<code><></code>) in place of type arguments, in which case the latter will be inferred. The following code in Java SE 7 is equivalent to the code in the previous example:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>Mapper<CustomList, Integer> mapper = new Mapper<>();

</pre></div>

When declaring a variable for a parameterized type, it is possible to use wildcards instead of explicit type names. Wildcards are expressed by writing <code>?</code> sign instead of the actual type. It is possible to limit possible types to the subclasses or superclasses of some specific class by writing the <code>extends</code> keyword or the <code>super</code> keyword correspondingly followed by the class name.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>/* Any Mapper instance with CustomList as the first parameter

may be used regardless of the second one.*/

Mapper<CustomList, ?> mapper;

mapper = new Mapper<CustomList, Boolean>();

mapper = new Mapper<CustomList, Integer>();

/* Will not accept types that use anything but

a subclass of Number as the second parameter */

void addMapper(Mapper<?, ? extends Number> mapper) {

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Generic_methods_and_constructors">Generic methods and constructors</h3></div>

Usage of generics may be limited to some particular methods, this concept applies to constructors as well. To declare a parameterized method, type variables are written before the return type of the method in the same format as for the generic classes. In the case of constructor, type variables are declared before the constructor name.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>class Mapper {

// The class itself is not generic, the constructor is

<T, V> Mapper(T array, V item) {

}

}

/* This method will accept only arrays of the same type as

the searched item type or its subtype*/

static <T, V extends T> boolean contains(T item, V[] arr) {

for (T currentItem : arr) {

if (item.equals(currentItem)) {

return true;

}

return false;

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Generic_interfaces">Generic interfaces</h3></div>

Interfaces can be parameterized in the similar manner as the classes.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>interface Expandable<T extends Number> {

void addItem(T item);

}

// This class is parameterized

class Array<T extends Number> implements Expandable<T> {

}

}

// And this is not and uses an explicit type instead

class IntegerArray implements Expandable<Integer> {

void addItem(Integer item) {

}

}

</pre></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .portalbox{padding:0;margin:0.5em 0;display:table;box-sizing:border-box;max-width:175px;list-style:none}.mw-parser-output .portalborder{border:1px solid var(--border-color-base,#a2a9b1);padding:0.1em;background:var(--background-color-neutral-subtle,#f8f9fa)}.mw-parser-output .portalbox-entry{display:table-row;font-size:85%;line-height:110%;height:1.9em;font-style:italic;font-weight:bold}.mw-parser-output .portalbox-image{display:table-cell;padding:0.2em;vertical-align:middle;text-align:center}.mw-parser-output .portalbox-link{display:table-cell;padding:0.2em 0.2em 0.2em 0.3em;vertical-align:middle}@media(min-width:720px){.mw-parser-output .portalleft{margin:0.5em 1em 0.5em 0}.mw-parser-output .portalright{clear:right;float:right;margin:0.5em 0 0.5em 1em}}

/* end https://en.wikipedia.org/ */

</style>

<ul><li><a href="Java_Platform%2C_Standard_Edition" title="Java Platform, Standard Edition">Java Platform, Standard Edition</a></li>

<li><a href="C_Sharp_syntax" title="C Sharp syntax">C Sharp syntax</a></li>

<li><a href="C%2B%2B_syntax" title="C++ syntax">C++ syntax</a></li>

<li><a href="C_syntax" title="C syntax">C syntax</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html">"Operators (The Java™ Tutorials > Learning the Java Language > Language Basics)"</a>. docs.oracle.com. Oracle and/or its affiliates. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150624161036/http://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html">Archived</a> from the original on June 24, 2015. Retrieved June 16, 2015.</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html">"The switch Statement (The Java™ Tutorials > Learning the Java Language > Language Basics)"</a>. docs.oracle.com. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20100315060844/http://java.sun.com/docs/books/tutorial/java/nutsandbolts/switch.html">Archived</a> from the original on March 15, 2010. Retrieved August 15, 2021.</cite>

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <cite id="CITEREFOwens" class="citation web cs1">Owens, Sean. <a rel="nofollow" class="external text" href="http://darksleep.com/player/JavaAndUnsignedTypes.html">"Java and unsigned int, unsigned short, unsigned byte, unsigned long, etc. (Or rather, the lack thereof)"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20090220171410/http://darksleep.com/player/JavaAndUnsignedTypes.html">Archived</a> from the original on February 20, 2009. Retrieved April 21, 2010.</cite>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html">"Primitive Data Types"</a>.</cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html">"Chapter 8. Classes"</a>. docs.oracle.com. Retrieved April 25, 2024.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.oracle.com/javase/tutorial/java/IandI/final.html">"Writing Final Classes and Methods"</a>. docs.oracle.com. Retrieved April 25, 2024.</cite>

</li>

<li id="cite_note-7"><a href="#cite_ref-7">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20090208100217/http://www.ibm.com/developerworks/java/library/j-jtp1029.html">"Java theory and practice: Is that your final answer?"</a>. developer.ibm.com. Archived from <a rel="nofollow" class="external text" href="http://www.ibm.com/developerworks/java/library/j-jtp1029.html">the original</a> on February 8, 2009. Retrieved April 25, 2024.</cite>

</li>

<li id="cite_note-8"><a href="#cite_ref-8">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html">"Lambda Expressions (The Java™ Tutorials > Learning the Java Language > Classes and Objects)"</a>. docs.oracle.com. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20200616055353/https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html">Archived</a> from the original on June 16, 2020. Retrieved August 8, 2021.</cite>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://msdn.microsoft.com/en-us/library/f4a6ta2h.aspx">"Generics in the Run Time (C# Programming Guide)"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160310012449/https://msdn.microsoft.com/en-us/library/f4a6ta2h.aspx">Archived</a> from the original on March 10, 2016. Retrieved March 9, 2016.</cite>

</li>

</ol></div></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .refbegin{margin-bottom:0.5em}.mw-parser-output .refbegin-hanging-indents>ul{margin-left:0}.mw-parser-output .refbegin-hanging-indents>ul>li{margin-left:0;padding-left:3.2em;text-indent:-3.2em}.mw-parser-output .refbegin-hanging-indents ul,.mw-parser-output .refbegin-hanging-indents ul li{list-style:none}@media(max-width:720px){.mw-parser-output .refbegin-hanging-indents>ul>li{padding-left:1.6em;text-indent:-1.6em}}.mw-parser-output .refbegin-columns{margin-top:0.3em}.mw-parser-output .refbegin-columns ul{margin-top:0}.mw-parser-output .refbegin-columns li{page-break-inside:avoid;break-inside:avoid-column}@media screen{.mw-parser-output .refbegin{font-size:90%}}

/* end https://en.wikipedia.org/ */

</style><div class="refbegin" style="">

<ul><li><cite id="CITEREFNaughtonSchildt1999" class="citation book cs1"><a href="Patrick_Naughton" class="new" title="Patrick Naughton (page does not exist)">Naughton, Patrick</a>; <a href="Herbert_Schildt" title="Herbert Schildt">Schildt, Herbert</a> (1999). Java 2: The Complete Reference (3rd ed.). The McGraw-Hill Companies. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-07-211976-4</bdi>.</cite></li>

<li><cite id="CITEREFVermeulenAmblerBumgardnerMetz2000" class="citation book cs1">Vermeulen; Ambler; Bumgardner; Metz; Misfeldt; Shur; Thompson (2000). <a rel="nofollow" class="external text" href="https://archive.org/details/elementsofjavast00verm">The Elements of Java Style</a>. Cambridge University Press. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-521-77768-2</bdi>.</cite></li>

<li><cite id="CITEREFGoslingJoySteeleBracha2005" class="citation book cs1"><a href="James_Gosling" title="James Gosling">Gosling, James</a>; <a href="Bill_Joy" title="Bill Joy">Joy, Bill</a>; <a href="Guy_L._Steele_Jr." title="Guy L. Steele Jr.">Steele, Guy</a>; Bracha, Gilad (2005). <a rel="nofollow" class="external text" href="http://java.sun.com/docs/books/jls/">Java Language Specification</a> (3rd ed.). Addison-Wesley Professional. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20090226152425/http://java.sun.com/docs/books/jls/">Archived</a> from the original on February 26, 2009. Retrieved December 3, 2008.</cite></li></ul>

</div>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .side-box{margin:4px 0;box-sizing:border-box;border:1px solid #aaa;font-size:88%;line-height:1.25em;background-color:var(--background-color-interactive-subtle,#f8f9fa);display:flow-root}.mw-parser-output .infobox .side-box{font-size:100%}.mw-parser-output .side-box-abovebelow,.mw-parser-output .side-box-text{padding:0.25em 0.9em}.mw-parser-output .side-box-image{padding:2px 0 2px 0.9em;text-align:center}.mw-parser-output .side-box-imageright{padding:2px 0.9em 2px 0;text-align:center}@media(min-width:500px){.mw-parser-output .side-box-flex{display:flex;align-items:center}.mw-parser-output .side-box-text{flex:1;min-width:0}}@media(min-width:720px){.mw-parser-output .side-box{width:238px}.mw-parser-output .side-box-right{clear:right;float:right;margin-left:1em}.mw-parser-output .side-box-left{margin-right:1em}}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1237033735">

/* start https://en.wikipedia.org/ */

@media print{body.ns-0 .mw-parser-output .sistersitebox{display:none!important}}@media screen{html.skin-theme-clientpref-night .mw-parser-output .sistersitebox img[src*="Wiktionary-logo-en-v2.svg"]{background-color:white}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .sistersitebox img[src*="Wiktionary-logo-en-v2.svg"]{background-color:white}}

/* end https://en.wikipedia.org/ */

</style><div class="side-box side-box-right sistersitebox"><style data-mw-deduplicate="TemplateStyles:r1126788409">

/* start https://en.wikipedia.org/ */

.mw-parser-output .plainlist ol,.mw-parser-output .plainlist ul{line-height:inherit;list-style:none;margin:0;padding:0}.mw-parser-output .plainlist ol li,.mw-parser-output .plainlist ul li{margin-bottom:0}

/* end https://en.wikipedia.org/ */

</style>

<div class="side-box-text plainlist">Wikibooks has a book on the topic of: <a href="https://en.wikibooks.org/wiki/Java_Programming/Syntax" class="extiw external" title="wikibooks:Java Programming/Syntax">Java Programming/Syntax</a></div></div>

</div>

<ul><li><a rel="nofollow" class="external text" href="https://docs.oracle.com/javase/specs/">The Java Language Specification, Third edition</a> Authoritative description of the Java language</li>

<li><a rel="nofollow" class="external text" href="https://docs.oracle.com/en/java/javase/24/docs/api/">Java SE 24 API Javadocs</a></li></ul>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="Java_(software_platform)419" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="3"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="Java_(software_platform)419" style="font-size:114%;margin:0 4em"><a href="Java_(software_platform)" title="Java (software platform)">Java (software platform)</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">Platforms</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<li><a href="Java_Platform%2C_Micro_Edition" title="Java Platform, Micro Edition">Java ME</a> (Micro)</li>

<li><a href="Java_Platform%2C_Standard_Edition" title="Java Platform, Standard Edition">Java SE</a> (Standard)</li>

<li><a href="Jakarta_EE" title="Jakarta EE">Jakarta EE</a> (Enterprise)</li>

<li><a href="Android_software_development#SDK" title="Android software development">Android SDK</a></li>

<li><a href="GraalVM" title="GraalVM">GraalVM</a></li></ul>

</div></td><td class="noviewer navbox-image" rowspan="5" style="width:1px;padding:0 0 0 2px"><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Technologies</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%">Oracle</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Squawk_virtual_machine" title="Squawk virtual machine">Squawk</a></li>

<li><a href="Java_Development_Kit" title="Java Development Kit">Java Development Kit</a></li>

<li><a href="OpenJDK" title="OpenJDK">OpenJDK</a></li>

<li><a href="Java_virtual_machine" title="Java virtual machine">Java virtual machine</a></li>

<li><a href="JavaFX" title="JavaFX">JavaFX</a></li>

<li><a href="Maxine_Virtual_Machine" title="Maxine Virtual Machine">Maxine VM</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Platform</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Java_applet" title="Java applet">Applets</a></li>

<li><a href="Jakarta_Servlet" title="Jakarta Servlet">Servlets</a></li>

<li><a href="MIDlet" title="MIDlet">MIDlets</a></li>

<li><a href="Java_Web_Start" title="Java Web Start">Web Start</a> (JNLP)</li>

<li><a href="Java_Platform_Module_System" title="Java Platform Module System">Modules</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Major third-party</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Blackdown_Java" title="Blackdown Java">Blackdown</a></li>

<li><a href="Eclipse_(software)" title="Eclipse (software)">Eclipse</a></li>

<li><a href="GNU_Classpath" title="GNU Classpath">GNU Classpath</a></li>

<li><a href="Apache_Harmony" title="Apache Harmony">Harmony</a></li>

<li><a href="Hibernate_(framework)" title="Hibernate (framework)">Hibernate</a></li>

<li><a href="IcedTea" title="IcedTea">IcedTea</a></li>

<li><a href="Jazelle" title="Jazelle">Jazelle</a></li>

<li><a href="Spring_Framework" title="Spring Framework">Spring</a></li>

<li><a href="Apache_Struts" title="Apache Struts">Struts</a></li>

<li><a href="Oracle_TopLink" title="Oracle TopLink">TopLink</a></li>

<li><a href="WildFly" title="WildFly">WildFly</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">History</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Java_version_history" title="Java version history">Java version history</a></li>

<li><a href="Java_Community_Process" title="Java Community Process">Java Community Process</a></li>

<li><a href="Sun_Microsystems" title="Sun Microsystems">Sun Microsystems</a></li>

<li><a href="Free_Java_implementations" title="Free Java implementations">Free Java implementations</a></li>

<li>Slogan: <a href="Write_once%2C_run_anywhere" title="Write once, run anywhere">Write once, run anywhere</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="List_of_JVM_languages" title="List of JVM languages">JVM languages</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<li><a href="BeanShell" title="BeanShell">BeanShell</a></li>

<li><a href="Clojure" title="Clojure">Clojure</a></li>

<li><a href="Groovy_(programming_language)" class="mw-redirect" title="Groovy (programming language)">Groovy</a></li>

<li><a href="JRuby" title="JRuby">JRuby</a></li>

<li><a href="Jython" title="Jython">Jython</a></li>

<li><a href="Kotlin_(programming_language)" title="Kotlin (programming language)">Kotlin</a></li>

<li><a href="Processing" title="Processing">Processing</a></li>

<li><a href="Rhino_(JavaScript_engine)" title="Rhino (JavaScript engine)">Rhino</a></li>

<li><a href="Scala_(programming_language)" title="Scala (programming language)">Scala</a></li>

<li><a href="Oxygene_(programming_language)" title="Oxygene (programming language)">Oxygene</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Community</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%">Conferences</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="JavaOne" title="JavaOne">JavaOne</a></li>

<li><a href="Devoxx" title="Devoxx">Devoxx</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Organizations</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Apache_Software_Foundation" class="mw-redirect" title="Apache Software Foundation">Apache Software Foundation</a></li>

<li><a href="Eclipse_Foundation" title="Eclipse Foundation">Eclipse Foundation</a></li>

<li><a href="Java_Community_Process" title="Java Community Process">Java Community Process</a></li>

<li><a href="Oracle_Corporation" title="Oracle Corporation">Oracle Corporation</a></li>

<li><a href="Sun_Microsystems" title="Sun Microsystems">Sun Microsystems</a>, <a href="Sun_Microsystems_Laboratories" class="mw-redirect" title="Sun Microsystems Laboratories">Sun Microsystems Laboratories</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">People</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="James_Gosling" title="James Gosling">James Gosling</a></li>

<li><a href="Arthur_van_Hoff" title="Arthur van Hoff">Arthur van Hoff</a></li>

<li><a href="Urs_H%C3%B6lzle" title="Urs Hölzle">Urs Hölzle</a></li>

<li><a href="Patrick_Naughton" class="new" title="Patrick Naughton (page does not exist)">Patrick Naughton</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><td class="navbox-abovebelow" colspan="3"><div> Category • <a href="Portal%3AComputer_programming" title="Portal:Computer programming">Computer programming portal</a></div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-07-13" href="https://en.wikipedia.org/wiki/?title=Java_syntax&oldid=1300342497">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>